.TH std::pmr::polymorphic_allocator 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::pmr::polymorphic_allocator \- std::pmr::polymorphic_allocator

.SH Synopsis
   Defined in header <memory_resource>
   template< class T >                  \fI(since C++17)\fP
   class polymorphic_allocator;         \fI(until C++20)\fP
   template< class T = std::byte >      \fI(since C++20)\fP
   class polymorphic_allocator;

   The class template std::pmr::polymorphic_allocator is an Allocator which exhibits
   different allocation behavior depending upon the std::pmr::memory_resource from
   which it is constructed. Since memory_resource uses runtime polymorphism to manage
   allocations, different container instances with polymorphic_allocator as their
   static allocator type are interoperable, but can behave as if they had different
   allocator types.

   All specializations of polymorphic_allocator meet the allocator completeness
   requirements.

   The polymorphic_allocator::construct member function does uses-allocator
   construction, so that the elements of a container using a polymorphic_allocator will
   use that same allocator for their own allocations. For example, a
   std::pmr::vector<std::pmr::string> will use the same memory_resource for the
   vector's storage and each string's storage.

   For non-polymorphic allocators, similar propagation can be achieved with the help of
   std::scoped_allocator_adaptor.

.SH Member types

   Member type definition
   value_type  T

.SH Member functions

   constructor                           constructs a polymorphic_allocator
                                         \fI(public member function)\fP
   destructor                            implicitly declared destructor
   (implicitly declared)                 \fI(public member function)\fP
   operator=                             copy assignment operator is deleted
   [deleted]                             \fI(public member function)\fP
.SH Public member functions
   allocate                              allocate memory
                                         \fI(public member function)\fP
   deallocate                            deallocate memory
                                         \fI(public member function)\fP
   construct                             constructs an object in allocated storage
                                         \fI(public member function)\fP
   destroy                               destroys an object in allocated storage
   (deprecated in C++20)                 \fI(public member function)\fP
   (undeprecated in C++26)
   allocate_bytes                        allocate raw aligned memory from the
   (C++20)                               underlying resource
                                         \fI(public member function)\fP
   deallocate_bytes                      free raw memory obtained from allocate_bytes
   (C++20)                               \fI(public member function)\fP
   allocate_object                       allocates raw memory suitable for an object or
   (C++20)                               an array
                                         \fI(public member function)\fP
   deallocate_object                     frees raw memory obtained by allocate_object
   (C++20)                               \fI(public member function)\fP
   new_object                            allocates and constructs an object
   (C++20)                               \fI(public member function)\fP
   delete_object                         destroys and deallocates an object
   (C++20)                               \fI(public member function)\fP
                                         create a new polymorphic_allocator for use by
   select_on_container_copy_construction a container's copy constructor
                                         \fI(public member function)\fP
                                         returns a pointer to the underlying memory
   resource                              resource
                                         \fI(public member function)\fP

.SH Non-member functions

   operator==         compare two polymorphic_allocators
   operator!=         \fI(function)\fP
   (removed in C++20)

.SH Notes

   polymorphic_allocator does not propagate on container copy assignment, move
   assignment, or swap. As a result, move assignment of a polymorphic_allocator-using
   container can throw, and swapping two polymorphic_allocator-using containers whose
   allocators do not compare equal results in undefined behavior.

         Feature-test macro         Value    Std                 Feature
   __cpp_lib_polymorphic_allocator 201902L (C++20) std::pmr::polymorphic_allocator<> as
                                                   a vocabulary type

.SH See also

   memory_resource an abstract interface for classes that encapsulate memory resources
   \fI(C++17)\fP         \fI(class)\fP
